from random import shuffle

class Pine:

	def __init__(self, color):
		
		''' metodo construtor da classe Pine'''
		
		self.color = color

	def get_color(self):
		
		'''retorna a cor do pino'''
		
		return self.color

	def __cmp__(self, other_pine):
		
		'''compara dois pinos;
		retorna True - mesma cor
		retorn False - cores diferentes'''
		
		if isinstance(other_pine, Pine):
			return cmp(self.get_color(),other_pine.get_color())
		return -1

	def __str__(self):
		
		'''retorna a cor do pino'''
		
		return str(self.get_color())

class Block:

        def __init__(self, size):
        	
        	'''metodo construtor da classe Block'''
        	
                self.pines = [None for e in xrange(size)]

        def add_pine(self, pine, position):
        	
        	'''adiciona pino em determinada posicao;
        	retorna False - pino nao adicionado 
        	retorna True - pino adicionado'''
        	
        	if not isinstance(self.pines[position], Pine):
	            self.pines[position] = pine
	            return True
    		return False
    	

        def get_pine(self, position):
        	
        	''' retorna o pino da posicao desejada '''
        	
                if position < 0 or position >= len(self):
                        raise 'InvalidPosition'
                return self.pines[position]

        def contains(self, pine):
        	
        	'''verifica se algum bloco tem determinado pino; 
        	retorna False - bloco nao contem pino 
        	retorna True - bloco contem pino'''
        	
        	for pine_2 in self.pines:
        		if pine == pine_2:
        			return True
        	return False
        	
        def assert_position(self, pine, position):
        	
        	'''verifica se o pino esta na posicao correta 
        	retorna True ou False'''
        	
        	return self.get_pine(position) == pine
        
        def result_block(self, block):
        	
        	'''retorna o bloco de acertos
        	black adicionado ao bloco - acerto de posicao
        	white adicionado ao bloco - acerto apenas da cor'''
        	
        	hit = Block(len(block))
        	for position in xrange(len(block)):
        		if self.assert_position(block.get_pine(position), position):
        			hit.pines[position] = Pine('black')
        		elif self.contains(block.get_pine(position)):
        			hit.pines[position] = Pine('white')
        	shuffle(hit.pines)
        	return hit
        
        def remove_pine(self, position):
        	
        	'''remove o pino da posicao desejada'''
       	
        	self.pines[position] = None
             			         	        	        	
        def __cmp__(self, other_block):
        	
        	'''compara se dois blocos sao iguais
        	retorna -1 - blocos diferentes
        	retorna 0 - blocos iguais'''
        	
                if isinstance(other_block, Block):
                    if len(self) == len(other_block):
                        for position in range(len(self)):
                                my_pine = self.get_pine(position)
                                other_pine = other_block.get_pine(position)
                                if my_pine != other_pine:
                                        return -1
                        return 0
                else:
                        return -1

        def __len__(self):
        	
        	'''metodo construtor para ler os pinos de um bloco'''
        	
                return len(self.pines)
               
        def __str__(self):
        	
        	'''ao utilizar o metodo print, e impresso as pinos do bloco'''
        	
        	block = ''
        	for pine in self.pines:
        		block += '%s ' % (pine)
        	return block
